package univers;

import univers.Domaine.Obstacle.TypeObstacle;

public class Domaine {

    public static int minX = 1;
    public static int maxX = 8;
    public static int minY = 1;
    public static int maxY = 8;
    public static Point Origine;
    public Obstacle obstacle;

    public Domaine() {
        new Vecteur();
        obstacle = new Obstacle();
        Origine = new Point(1, 1);
    }

    static class Vecteur {

        int u, v;
        static Vecteur nord,  sud,  est,  ouest;
        static Vecteur nord_est,  sud_est,  nord_ouest,  sud_ouest;
        static Vecteur[] Direction;

        Vecteur() {
            nord = new Vecteur(1, 0);
            sud = new Vecteur(-1, 0);
            est = new Vecteur(0, 1);
            ouest = new Vecteur(0, -1);

            nord_est = nord.plus(est);
            sud_est = sud.plus(est);
            nord_ouest = nord.plus(ouest);
            sud_ouest = sud.plus(ouest);

            Direction = new Vecteur[8];
            Direction[0] = nord;
            Direction[1] = nord_est;
            Direction[2] = est;
            Direction[3] = sud_est;
            Direction[4] = sud;
            Direction[5] = sud_ouest;
            Direction[6] = ouest;
            Direction[7] = nord_ouest;
        }

        Vecteur(int u, int v) {
            this.u = u;
            this.v = v;
        }

        Vecteur plus(Vecteur vect) {
            return new Vecteur(u + vect.u, v + vect.v);
        }

        @Override
        public String toString() {
            return this.getClass().getSimpleName();
        }
    }

    public class Point {

        int X, Y;

        Point(int X, int Y) {

            this.X = X;
            this.Y = Y;
        }

        @Override
        public String toString() {
            return "(" + X + "," + Y + ")";
        }

        Point copy() throws CloneNotSupportedException {
            return new Point(this.X, this.Y);
        }

        @Override
        public boolean equals(Object objet) {
            if (objet == this) {
                return true;
            }
            if (objet instanceof Point) {
                Point p = (Point) objet;
                if ((X != p.X) | (Y != p.Y)) {
                    return false;
                } else {
                    return true;
                }
            }

            return false;
        }

        @Override
        public int hashCode() {
            int hash = 7;
            hash = 53 * hash + this.X;
            hash = 53 * hash + this.Y;
            return hash;
        }
    }

    public void ajoutObstacle(int X, int Y, boolean etat) {
        obstacle.addType(X, Y, etat);
    }

    public class Obstacle {

        TypeObstacle[][] LEtats;

        private void addType(int X, int Y, boolean etat) {
            LEtats[X][Y] = new TypeObstacle(etat);

        }

        public class TypeObstacle {

            String Nom;
            boolean Etat;

            public TypeObstacle(boolean etat) {
                Etat = etat;
                if (etat) {
                    Nom = "wpw";
                } else {
                    Nom = "bpw";
                }
            }

            public boolean Etat() {
                return Etat;
            }

            public String getNom() {
                return Nom;
            }
        }

        public Obstacle() {
            LEtats = new TypeObstacle[maxX + 1][maxY + 1];
        }

        public Obstacle(TypeObstacle[][] liste) {
            this.LEtats = liste;
        }

        public TypeObstacle[][] getListe() {
            return LEtats;
        }
    }
}
